/// 智能媒体文件下载和转换测试
/// Author: Lily
/// 
/// 按照用户要求下载真实的媒体文件并进行智能转换测试
/// 支持TS视频文件和JPEG图片序列

use std::path::Path;
use tokio::fs::File;
use tokio::io::AsyncReadExt;

// 导入我们的转换器
use videoDownloader::converter::{ConverterFactory, ConversionOptions};
use videoDownloader::error::DownloadResult;

#[tokio::main]
async fn main() -> DownloadResult<()> {
    println!("🎬 智能媒体文件下载和转换测试");
    println!("============================================");
    
    // 按照用户要求使用指定的URL
    let test_url = "https://surrit.com/80578501-ee80-4633-9c30-acbae2cf2f76/720p/video.m3u8";
    
    // 1. 下载真实的媒体数据
    println!("📥 开始下载真实媒体数据...");
    download_media_data(test_url).await?;
    
    // 2. 智能检测并测试转换
    println!("🔄 开始智能媒体转换测试...");
    test_smart_media_conversion().await?;
    
    println!("✅ 智能转换测试完成！");
    Ok(())
}

/// 下载真实的媒体数据（TS或JPEG）
async fn download_media_data(m3u8_url: &str) -> DownloadResult<()> {
    let client = reqwest::Client::new();
    
    // 先获取m3u8文件
    println!("📋 下载m3u8播放列表: {}", m3u8_url);
    let response = client.get(m3u8_url).send().await
        .map_err(|e| videoDownloader::error::DownloadError::Network(e.to_string()))?;
    let m3u8_content = response.text().await
        .map_err(|e| videoDownloader::error::DownloadError::Network(e.to_string()))?;
    
    println!("📝 M3U8内容预览:");
    for (i, line) in m3u8_content.lines().take(10).enumerate() {
        println!("   {}: {}", i + 1, line);
    }
    
    // 解析媒体文件URL
    let base_url = if m3u8_url.contains('/') {
        m3u8_url.rsplit_once('/').unwrap().0.to_string() + "/"
    } else {
        String::new()
    };
    
    let mut media_urls = Vec::new();
    
    for line in m3u8_content.lines() {
        if (line.ends_with(".ts") || line.ends_with(".jpeg") || line.ends_with(".jpg")) && media_urls.len() < 10 {
            let file_url = if line.starts_with("http") {
                line.to_string()
            } else {
                format!("{}{}", base_url, line)
            };
            media_urls.push(file_url);
        }
    }
    
    println!("🎯 找到 {} 个媒体文件URL，开始下载前{}个...", media_urls.len(), media_urls.len().min(10));
    
    // 创建smart_media_data目录（不删除已有文件）
    std::fs::create_dir_all("smart_media_data")?;
    
    for (i, file_url) in media_urls.iter().enumerate() {
        // 根据文件扩展名确定文件名
        let extension = if file_url.ends_with(".jpeg") {
            "jpeg"
        } else if file_url.ends_with(".jpg") {
            "jpg" 
        } else {
            "ts"
        };
        
        let filename = format!("smart_media_data/segment_{:03}.{}", i, extension);
        
        // 检查文件是否已存在
        if Path::new(&filename).exists() {
            let metadata = std::fs::metadata(&filename)?;
            println!("♻️  复用已存在文件: {} ({} bytes)", filename, metadata.len());
            continue;
        }
        
        println!("📦 下载文件 {}/{}: {}", i + 1, media_urls.len(), file_url);
        
        let response = client.get(file_url).send().await
            .map_err(|e| videoDownloader::error::DownloadError::Network(e.to_string()))?;
        let file_data = response.bytes().await
            .map_err(|e| videoDownloader::error::DownloadError::Network(e.to_string()))?;
        
        tokio::fs::write(&filename, &file_data).await?;
        
        println!("  ✅ 保存到: {} ({} bytes)", filename, file_data.len());
        
        // 分析文件头并重命名文件
        if file_data.len() >= 4 {
            if file_data[0] == 0x47 {
                // 这是TS文件，重命名
                let correct_filename = format!("smart_media_data/segment_{:03}.ts", i);
                tokio::fs::rename(&filename, &correct_filename).await?;
                println!("     📺 检测到TS文件（同步字节: 0x47），重命名为: {}", correct_filename);
            } else if file_data[0] == 0xFF && file_data[1] == 0xD8 {
                println!("     🖼️  JPEG图片文件");
            } else {
                println!("     ❓ 未知文件类型（首字节: 0x{:02X}）", file_data[0]);
            }
        }
    }
    
    println!("✅ 真实媒体数据下载完成！");
    Ok(())
}

/// 智能检测媒体文件类型并选择合适的转换器
async fn test_smart_media_conversion() -> DownloadResult<()> {
    println!("\n🔧 检测媒体文件类型并选择合适的转换器...");
    
    // 检查下载的文件类型
    let test_dir = Path::new("smart_media_data");
    let mut ts_files = Vec::new();
    let mut jpeg_files = Vec::new();
    
    if let Ok(entries) = std::fs::read_dir(test_dir) {
        for entry in entries {
            if let Ok(entry) = entry {
                let path = entry.path();
                match path.extension().and_then(|s| s.to_str()) {
                    Some("ts") => ts_files.push(path),
                    Some("jpeg") | Some("jpg") => jpeg_files.push(path),
                    _ => {}
                }
            }
        }
    }
    
    ts_files.sort();
    jpeg_files.sort();
    
    println!("📁 找到: {} 个TS文件, {} 个JPEG文件", ts_files.len(), jpeg_files.len());
    
    // 根据文件类型选择转换策略
    if !ts_files.is_empty() {
        println!("🎬 检测到TS文件，使用TS到MP4转换器...");
        test_ts_conversion(&ts_files).await?;
    } else if !jpeg_files.is_empty() {
        println!("🖼️  检测到JPEG序列，使用图片转换器...");
        test_jpeg_conversion(&jpeg_files).await?;
    } else {
        println!("⚠️  没有找到支持的媒体文件");
        return Ok(());
    }
    
    Ok(())
}

/// 测试TS文件转换
async fn test_ts_conversion(ts_files: &[std::path::PathBuf]) -> DownloadResult<()> {
    // 创建TS到MP4转换器
    let mut converter = ConverterFactory::create_ts_to_mp4_converter(128 * 1024);
    
    println!("📁 开始加载 {} 个TS文件...", ts_files.len());
    
    let mut total_size = 0;
    
    // 将TS数据添加到转换器
    for (i, ts_file) in ts_files.iter().enumerate() {
        println!("📖 读取: {}", ts_file.display());
        
        let mut file = File::open(ts_file).await?;
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).await?;
        
        total_size += buffer.len();
        converter.add_data(&buffer);
        println!("  ✅ 添加 {} bytes 到转换器 ({}/{})", buffer.len(), i + 1, ts_files.len());
        
        // 验证TS包结构
        let packet_count = buffer.len() / 188;
        println!("     📊 包含 {} 个TS包 (188字节/包)", packet_count);
    }
    
    println!("📊 总数据量: {:.2} MB", total_size as f64 / 1024.0 / 1024.0);
    
    // 执行转换
    println!("\n🎬 开始TS到MP4转换...");
    let output_path = Path::new("smart_media_data/output_ts.mp4");
    
    let options = ConversionOptions {
        output_format: "mp4".to_string(),
        quality: None,
        preserve_encoding: true,
        custom_params: Vec::new(),
    };
    
    converter.convert_with_options(output_path, &options).await?;
    
    validate_output_file(output_path, "TS转MP4").await?;
    Ok(())
}

/// 测试JPEG序列转换
async fn test_jpeg_conversion(jpeg_files: &[std::path::PathBuf]) -> DownloadResult<()> {
    // 创建图片转换器
    let mut converter = ConverterFactory::create_image_converter(64 * 1024, "jpeg");
    
    println!("📁 开始加载 {} 个JPEG文件...", jpeg_files.len());
    
    let mut total_size = 0;
    
    // 将JPEG数据添加到转换器
    for (i, jpeg_file) in jpeg_files.iter().enumerate() {
        println!("📖 读取: {}", jpeg_file.display());
        
        let mut file = File::open(jpeg_file).await?;
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).await?;
        
        total_size += buffer.len();
        converter.add_data(&buffer);
        println!("  ✅ 添加 {} bytes 到转换器 ({}/{})", buffer.len(), i + 1, jpeg_files.len());
        
        // 验证JPEG文件头
        if buffer.len() >= 2 && buffer[0] == 0xFF && buffer[1] == 0xD8 {
            println!("     🖼️  有效JPEG文件");
        } else {
            println!("     ⚠️  可能不是有效JPEG文件");
        }
    }
    
    println!("📊 总数据量: {:.2} MB", total_size as f64 / 1024.0 / 1024.0);
    
    // 执行转换
    println!("\n🖼️  开始JPEG序列转换...");
    let output_path = Path::new("smart_media_data/output_images.sequence");
    
    let options = ConversionOptions {
        output_format: "sequence".to_string(),
        quality: None,
        preserve_encoding: true,
        custom_params: Vec::new(),
    };
    
    converter.convert_with_options(output_path, &options).await?;
    
    validate_output_file(output_path, "JPEG序列合并").await?;
    Ok(())
}

/// 验证输出文件
async fn validate_output_file(output_path: &Path, conversion_type: &str) -> DownloadResult<()> {
    if output_path.exists() {
        let metadata = std::fs::metadata(output_path)?;
        println!("✅ {}文件生成成功！", conversion_type);
        println!("📄 文件位置: {}", output_path.display());
        println!("📊 文件大小: {} bytes ({:.2} MB)", metadata.len(), metadata.len() as f64 / 1024.0 / 1024.0);
        
        // 读取文件头进行基本验证
        let mut file = File::open(output_path).await?;
        let mut header = [0u8; 32];
        let bytes_read = file.read(&mut header).await?;
        
        if bytes_read >= 8 {
            // 检查MP4文件头
            if header[4..8] == *b"ftyp" {
                println!("✅ MP4文件头验证通过！");
                if bytes_read >= 12 {
                    let brand = std::str::from_utf8(&header[8..12]).unwrap_or("unknown");
                    println!("   📋 品牌: {}", brand);
                }
            } else {
                println!("📝 生成的是 {} 格式文件", conversion_type);
            }
        }
        
        // 尝试用ffprobe分析（如果可用）
        if output_path.extension().and_then(|s| s.to_str()) == Some("mp4") {
            if let Ok(output) = std::process::Command::new("ffprobe")
                .args(&["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams"])
                .arg(output_path.to_str().unwrap())
                .output() {
                if output.status.success() {
                    println!("🔍 FFprobe分析成功！");
                    let info = String::from_utf8_lossy(&output.stdout);
                    if info.contains("\"codec_name\"") {
                        println!("   📺 文件包含有效的媒体流");
                    }
                } else {
                    println!("⚠️  FFprobe分析失败，但文件已生成");
                }
            }
        }
    } else {
        return Err(videoDownloader::error::DownloadError::Conversion(
            format!("输出{}文件未生成", conversion_type)
        ));
    }
    
    println!("\n🎉 {}测试完成！", conversion_type);
    println!("💡 建议测试工具：");
    if output_path.extension().and_then(|s| s.to_str()) == Some("mp4") {
        println!("   - VLC播放器");
        println!("   - ffplay {}", output_path.display());
        println!("   - mediainfo {}", output_path.display());
    } else {
        println!("   - 文本编辑器查看序列文件");
        println!("   - 分离图片并使用图片查看器");
        println!("   - 使用FFmpeg转换为视频：ffmpeg -framerate 25 -f image2 -i smart_media_data/segment_%03d.jpeg output_video.mp4");
    }
    
    Ok(())
}